home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 February / PCWorld_2008-02_cd.bin / audio-video / reaper / reaper2028-install.exe / Effects / Till / Transient-driven Auto-Pan v1.0 (Slave) < prev    next >
Encoding:
Text File  |  2007-12-03  |  4.1 KB  |  192 lines
  1. // written by Till
  2. //
  3. // note: the effect receives data from reg[x] x is specified by the "receive pan data from" slider
  4. //
  5. // note: the lookahead must be compensated manually
  6. //
  7. // note: the frequency of data being received from the master depends on
  8. // the overall blocksize which is apparently depending on your interface's latency.
  9. // so the slave effect cannot always be up to date with the master effect
  10. // the quantisation is being interpolated linearly
  11.  
  12. desc: Transient-driven Auto-Pan (Slave)
  13. slider1:0<0,2,1{Stereo,Left,Right}>Input
  14. slider2:0<0,9,1{reg00,reg01,reg02,reg03,reg04,reg05,reg06,reg07,reg08,reg09}>Receive Pan data from
  15. slider3:0<-100,100,1>Received Pan
  16. slider4:0<0,10,1>Sloppiness
  17. slider5:0<0,1,1{No,Yes}>Invert received Pan
  18. slider6:1<.2,5,.1>Multiply received Pan by
  19. slider7:100<1,100,1>Max. Pan
  20. slider8:0<0,10,1>Max Delay (ms)
  21. slider9:0<0,100,1>Look-ahead (ms)
  22. slider10:0<-100,100,1>Current Pan
  23.  
  24.  
  25. /////////////////
  26. ///           ///
  27. ///  I N I T  ///
  28. ///           ///
  29. /////////////////
  30.  
  31. @init
  32.  
  33.     log2 = log(2);
  34.     sqrt2 = sqrt(2);
  35.  
  36.     curpan = 0;
  37.  
  38.     maxdelay = ceil((10 + 100) / 1000 * srate);
  39.  
  40.     delaybufferl = 0;
  41.     delaybufferr = 2 * maxdelay;
  42.  
  43.     delaypointer = 0;
  44.  
  45.     receivedpan = 0;
  46.     oldreceivedpan = 0;
  47.  
  48.     spls = 0;
  49.  
  50. /////////////////
  51. ///           ///
  52. ///  SLIDER   ///
  53. ///           ///
  54. /////////////////
  55.  
  56. @slider
  57.  
  58.     // SLIDER VALUES
  59.  
  60.     input = slider1;
  61.  
  62.     receive = slider2;
  63.  
  64.     sloppiness = slider4;
  65.  
  66.     invert = slider5;
  67.  
  68.     multiply = slider6;
  69.  
  70.     maxpan = slider7;
  71.  
  72.     delay = slider8 / 1000 * srate;
  73.  
  74.     lookahead = slider9 / 1000 * srate;
  75.  
  76. /////////////////
  77. ///           ///
  78. ///  BLOCK    ///
  79. ///           ///
  80. /////////////////
  81.  
  82. @block
  83.  
  84.     blocksize = samplesblock;
  85.  
  86. // receiving
  87.  
  88.     oldreceivedpan = receivedpan;
  89.  
  90.     receive == 0 ? (
  91.         receivedpan = reg00;
  92.     ) : receive == 1 ? (
  93.         receivedpan = reg01;
  94.     ) : receive == 2 ? (
  95.         receivedpan = reg02;
  96.     ) : receive == 3 ? (
  97.         receivedpan = reg03;
  98.     ) : receive == 4 ? (
  99.         receivedpan = reg04;
  100.     ) : receive == 5 ? (
  101.         receivedpan = reg5;
  102.     ) : receive == 6 ? (
  103.         receivedpan = reg6;
  104.     ) : receive == 7 ? (
  105.         receivedpan = reg7;
  106.     ) : receive == 8 ? (
  107.         receivedpan = reg8;
  108.     ) : receive == 9 ? (
  109.         receivedpan = reg09;
  110.     ) : 0;
  111.  
  112.     slider3 = receivedpan;
  113.  
  114.     spls = 0;
  115.  
  116. /////////////////
  117. ///           ///
  118. ///  SAMPLE   ///
  119. ///           ///
  120. /////////////////
  121.  
  122. @sample
  123.  
  124. // choosing input
  125.  
  126.     input == 0 ? (
  127.         l = spl0;
  128.         r = spl1;
  129.     ) : input == 1 ? (
  130.         l = spl0;
  131.         r = spl0;
  132.     ) : input == 2 ? (
  133.         l = spl1;
  134.         r = spl1;
  135.     ) : 0;
  136.  
  137. // buffering
  138.  
  139.     delaybufferl[delaypointer] = l;
  140.     delaybufferl[delaypointer + maxdelay] = l;
  141.     delaybufferr[delaypointer] = r;
  142.     delaybufferr[delaypointer + maxdelay] = r;
  143.  
  144. // interpolating receivedpan
  145.  
  146.     curpan = oldreceivedpan + (receivedpan - oldreceivedpan) * spls / blocksize;
  147.  
  148. // modifying input pan
  149.  
  150.     invert && curpan *= -1;
  151.     curpan *= multiply;
  152.     curpan = min(max(-maxpan, curpan), maxpan);
  153.  
  154. // sloppiness
  155.  
  156.     s = sloppiness * sloppiness * sloppiness * sloppiness;
  157.     curpan = (curpan + s * curpan) / (s + 1);
  158.  
  159. // calculating the actual volumes
  160.  
  161.     abspan = abs(curpan);
  162.     dominantpandb = 6 * abspan / 100;
  163.     dominantpan = exp((dominantpandb / 6) * log2);
  164.     recessivepan = 2 - dominantpan;
  165.  
  166. // leveling
  167.  
  168.     curpan > 0 ? (
  169.         r = dominantpan * delaybufferr[maxdelay + delaypointer - lookahead];
  170.         x = abspan / 100 * delay;
  171.         f = x - floor(x);
  172.         c = floor(x + 1) - x;
  173.         l = recessivepan * (c * delaybufferl[maxdelay + delaypointer - floor(abspan / 100 * delay) - lookahead] + f * delaybufferl[maxdelay + delaypointer - ceil(abspan / 100 * delay) - lookahead]);
  174.     ) : (
  175.         l = dominantpan * delaybufferl[maxdelay + delaypointer - lookahead];
  176.         x = abspan / 100 * delay;
  177.         f = x - floor(x);
  178.         c = floor(x + 1) - x;
  179.         r = recessivepan * (c * delaybufferr[maxdelay + delaypointer - floor(abspan / 100 * delay) - lookahead] + f * delaybufferr[maxdelay + delaypointer - ceil(abspan / 100 * delay) - lookahead]);
  180.     );
  181.  
  182.     slider10 = curpan;
  183.     
  184. // outputting
  185.  
  186.     spl0 = l;
  187.     spl1 = r;
  188.  
  189.     delaypointer += 1;
  190.     delaypointer >= maxdelay && (delaypointer = 0);
  191.  
  192.     spls += 1;